/**
 *  ts中的变量类型：
 *  语法：
 *  let 变量:类型 = 值
 * 
 *  布尔类型
 */
let b1: boolean = true;
// b1 = 123; //Error : Type 'number' is not assignable to type 'boolean'.
b1 = false;

/**
 * number
 */
let num1: number = 10;
// num1 = '123'; // Error 'string' is not assignable to type 'number'

/**
 * string
 */
let str1: string = '123';
// str1 = 10; // Error  Type 'number' is not assignable to type 'string'.

/**
 * null 和 undefined 
 * 
 * null 和 undefined 是任意类型的子类型。可以给其他类型赋值[非严格模式]
 */
// let n1:null = null;
// let unde1:undefined = undefined;

// 严格模式下不能赋值
// 非严格模式下可以赋值
// let obj:number[] = null;

let num: number = 123;
// num = null;

/**
 * 数组： number[]  数组每一个元素都要是数字
 */
// 方式一：
let list1: number[] = [1, 2, 3]
// 方式二：泛型方式定义
let list2: Array<number> = [1, 2, 3]
// list2[0] = 'a'; // Error Type 'string' is not assignable to type 'number'.

/**
 * 元组：特殊的数组，数组的长度和数组每个元素的类型已经确定了的数组
 */

let t1: [string, number]
t1 = ['hello', 10] // OK
// t1 = [10, 'hello'] // Error

/**
 * 枚举
 * 
 */
// let sex = 1  // 0    1 0  man woman  m  w     1 2 0

// if(sex === 1){

// }else if(sex === 0 ){

// }

enum Gender{
    man,
    woman=100,
    secret
}
console.log(Gender)

let sex = 1;
if(sex === Gender.man){
    
}else if(sex === Gender.woman){

}

/**
 * any: 任意类型,尽量少用any类型
 * 
 */
let str:any = 123;
str = 'string'
str = [123]


/**
 * void : 没有类型
 * 作用：一般用于修饰没有返回值的函数返回值类型
 * 
 */
function fn():void{

}
console.log(fn())

/**
 * object： 非 number ，string， boolean以外的类型
 * 
 * 用的很少，如果我们要对对象类型的数据进行精确的限定，我们会使用 interface 接口
 */

let obj1:object = {name:'yuonly', age:20}
obj1 = function(){

}
obj1 = [1,2,3,4]

/**
 * 联合类型  
 * let 变量:类型1 | 类型2 | 类型。。。。。 = 值
 * 
 * 
 * 
 */
let n:number | string | boolean = '123'
n = 123;
n = true;

function fn123(x:number | string){
    // 联合类型使用，必须使用共同都有的属性
    console.log(x.toString())
    // 类型断言
    // if((x as string).length){ // 方式一： as 断言语法

    if((<string>x).length){ // 方式二： 泛型断言语法
        console.log('字符串')
    }else{
        console.log('数字')
    }
}

/**
 * 类型断言： 
 * 方式一： as     变量 as 类型
 * 
 * 方式二： 泛型   <类型>变量
 */

/**
 * 类型推断：
 */
let a = 123;
// a = '123';

export { }